perm filename RLL.MSC[RLL,DBL] blob
sn#677959 filedate 1982-09-17 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00005 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 List of all sentences
C00015 00003 Predicate Calculus Statements for Various RLL things
C00022 00004 What's in a Language?
C00027 00005 Questions re: RLL
C00032 ENDMK
C⊗;
List of all sentences
1. All purple mushrooms are poisonous.
2. Everybody loves somebody. {Two meanings}
3. Purple mushrooms have many attributes.
4. There are 23 purple mushrooms in the world.
5. Purple-mushroom-23 has been accessed 12 times.
6. The fact that a purple mushroom is purple is definitional.
7. The integers mod 5 form a group under addtion.
8. John gave Mary the book.
9. Apple-23 embodies the {theory | concept} pf apple. [is an examplar]
10. The color of all singleton sets is red.
↓ 11. The alleged theif hated the poor violinist.
12. Most elephants are grey.
↓ 13. John poured some of the liquid out of the bottle.
? 14. Tower of Hanoi
!Need:
4 forms of Isa:
(1) Standard - NON-Definitional
Expresses merely relation of set membership
(2) Existential - for ∃xεS
(3) Universal - for ∀xεS
New Any$SELF$Slots: DefinitionalSlots and AttributeSlots
This may require splitting many slots into multiple slots.
Conventions:
Any--- is the set of all ---s
Typical--- is a typical element of this set of ---
Every Typical--- unit has a slot InheritableSlots, which points to slots...
also DefinitionalSlots
If sεAny$SELF$Slot,
TypicalDog
TypicalExampleOf: AnyDog
InheritableSlots: (Parts, ..., MyWorth)
Parts: (4 legs, ...)
MyWorth: 45
MyWorthForInstance: 33
MyWorth
Isa: (Any$SELF$Slot)
StoredInTypAs: MyWorthForInstance
Now when Dog#53 is initialized,
its MyWorth value with be 33, NOT 45 (45 is worth of TypicalDog, qua unit.)
** Note ***
Slot1
SuperSlot: SSlot
means
1. Domain(Slot1)=Domain(SSlot)
2. ∀xεUnit. Slot1(x) ⊂ SSlot(x)
Typical1
SuperTypEx: STypical
means
TypicalExampleOf( Typical1 ) ⊂ TypicalExampleOf( STypical )
!1. All purple mushrooms are poisonous.
*** SOLN#1 ***
AnyMushroom
SubClass: AnyPurpleMushroom
AnyPurpleThing
SubClass: AnyPurpleMushroom
AnyPurpleMushroom
TypicalExample: TypicalPurpleMushroom
TypicalPurpleMushroom
Poisonous: T
InheritableSlots: (Poisonous)
*** SOLN#2 ***
AnyMushroom
UniversalExamples: {x ... }
x
UniversalIsa: {AnyMushroom}
Color: Purple
Poisonous: T
DefinitionalSlots: {UniversalIsa, Color}
InheritableSlots: (Poisonous)
Isa
Isa: {Slot}
SubSlots: {ExistentialIsa, UniversalIsa, StandardIsa}
UniversalIsa
Isa: {Slot}
SuperSlots: {Isa}
*** SOLN#3 ***
AnyMushroom
UniversalExamples: {x ... }
AnyPoisonousThing
StdExamples: {x ... }
x
UniversalIsa: {AnyMushroom}
StdIsa: {AnyPosionousThing}
Color: Purple
DefinitionalSlots: {UniversalIsa, Color}
InheritableSlots: (Poisonous)
TROUBLE - unnatural!!!
*** SOLN#4 ***
AnyMushroom
SubClass: {x ... }
X
SuperClass: {AnyMushroom}
TypicalExample: TypicalX
DefinitionalSlots: {SuperClass, TypicalExample}
TypicalX
TypicalExampleOf: {X}
Poisonous: T
Color: Purple
? DefinitionalSlots: {?, Color}
InheritableSlots: (Poisonous)
!2a. Everybody loves somebody. ∀xεPerson ∃yεPerson. Loves(x,y)
AnyPerson
UniversalExamples: {x, y...}
x
UniversalIsa: {AnyPerson}
Loves: y
DefinitionalSlots: {UniversalIsa}
VariesThru: AnyPerson
y
ExistentialIsa: {AnyPerson}
LovedBy: x
DefinitionalSlots: {LovedBy, ExistentialIsa}
VariesWith: x
!2b. Everybody loves somebody. ∃yεPerson ∀xεPerson. Loves(x,y)
*** SOLN#1 ***
AnyPerson
TypicalExample: TypicalPerson
UniversalExamples: {y, ...}
TypicalPerson
TypicalExampleOf: AnyPerson
Loves: y
y
ExistentialIsa: {AnyPerson}
LovesBy: TypicalPerson
DefinitionalSlots: {LovedBy, ExistentialIsa}
VariesWith: NIL
*** SOLN#2 ***
AnyPerson
UniversalExamples: {x, y...}
x
UniversalIsa: {AnyPerson}
Loves: y
DefinitionalSlots: {UniversalIsa}
VariesThru: AnyPerson
y
ExistentialIsa: {AnyPerson}
LovesBy: TypicalPerson
DefinitionalSlots: {LovedBy, ExistentialIsa}
VariesWith: NIL
!3. Purple mushrooms have many attributes.
AnyMushroom
UniversalExamples: {x ... }
x
UniversalIsa: {AnyMushroom}
Color: Purple
Poisonous: T
DefinitionalSlots: {UniversalIsa, Color}
#Slots: Many
#Slots:
Isa: {Any$SELF$Slot}
!4. There are 23 purple mushrooms in the world.
AnyMushroom
Cardinality: 23
Cardinality
Isa: {Slot}
!5. Purple-mushroom-23 has been accessed 12 times.
AnyMushroom
Examples: {Purple-mushroom-23, ...}
Purple-mushroom-23
Isa: {AnyMushroom}
#Accesses: 12
#Accesses
Isa: {Any$SELF$Slot}
!6. The fact that a purple mushroom is purple is definitional.
AnyMushroom
UnverisalExamples: {x ... }
x
UniversalIsa: {AnyMushroom}
Color: Purple
Poisonous: T
DefinitionalSlots: {UniversalIsa, Color}
VariesThru: AnyMushroom
!7. Block1 and Block2 together form a blivit.
Block2 and Block3 together form a blivit.
Block1 and Block3 together form a blivit.
AnyBlivit
EssentialParts: {Whiggit, Whatever}
Examples: {Blivit-0, Blivit-32, Blivit-95 ...}
Blivit-0
Isa: (AnyBlivit)
Whiggit: Block1
Whatever: Block2
Blivit-32
Isa: (AnyBlivit)
Whiggit: Block2
Whatever: Block3
APartOf: Block3
Blivit-95
Isa: (AnyBlivit)
Whiggit: Block1
Whatever: Block3
Block1
Isa: {AnyBlock, AnyWhiggit}
WhiggitFor: (Blivit-0, Blivit-32)
APartOf: (Blivit-0, Blivit-32)
Block2
Isa: {AnyBlock, AnyWhiggit, AnyWhatever}
WhateverFor: (Blivit-0)
WhiggitFor: (Blivit-32)
APartOf: (Blivit-0, Blivit-32)
Block3
Isa: {AnyBlock, AnyWhatever}
WhiggitFor: (Blivit-32, Blivit-95)
APartOf: (Blivit-32, Blivit-95)
APartOf
Isa: (AnySlot)
SubSlots: (WhiggitFor, WhateverFor)
Whiggit
Isa: (AnySlot)
Inverse: WhiggitFor
Whatever
Isa: (AnySlot)
Inverse: WhateverFor
WhiggitFor
Isa: (AnySlot)
SuperSlots: (APartIn)
Inverse: Whiggit
WhateverFor
Isa: (AnySlot)
SuperSlots: (APartIn)
Inverse: Whatever
!8. John gave Mary the book.
AnyGivingEvent
Examples: {GE-41, ...}
GE-41
Giver: John
Recipient: Mary
Object: Book
John
GiverIn: GE-41
Mary
RecipientIn: GE-41
Book
ObjectIn: GE-41
GiverIn
Isa: {Slot}
SuperSlots: {ParticipatesIn}
RecipientIn
Isa: {Slot}
SuperSlots: {ParticipatesIn}
ObjectIn
Isa: {Slot}
SuperSlots: {ParticipatesIn}
!9. Apple-23 embodies the {theory | concept} pf apple. [is an examplar]
AnyApple
Examplar: Apple-23
Apple-23
ExamplarOf: AnyApple
Examplar
Isa: {Slot}
?
x = Examplar( S ) means:
1. x ε S
2. ∀yεS. ∀sεT. s(y) = s(x) most of the time.
where T = InheritableSlots(TypicalExample(S)).
[Rewording: ∀sεT. |{yεS | s(y) = s(x)}| ≥ 80% of |S| ]
!10. The color of all singleton sets is red.
AnySet
UniversalExamples: {x, ...}
x
UniversalIsa: {AnySet}
Cardinality: 1
DefinitionalSlots: {UniversalIsa, Cardinality}
Color: Red
!12. Most elephants are grey.
AnyElephant
TypicalExample: TypicalElephant
TypicalElephant
Propositions: {Prop-41, ...}
Grey
Isa: {AnyColor}
Propositions: {Prop-41, ...}
Prop-41
Relation: Color
Value: Grey
Modality: MostAre
FromUnit: TypicalElephant
Propositions
Isa: {Slot}
Datatype: ... (*P AnyProp) ...
AnyProp
TypicalExample: TypicalProp
TypicalProp
TypicalExampleOf: AnyProp
SensibleSlots: {Relation, Value, FromUnit, Modality, Tense, ...}
!-- Or --
AnyElephant
TypicalExample: TypicalElephant
TypicalElephant
Color: {(Prop Prop-41), ...}
Grey
Isa: {AnyColor}
ColorOf: {(Prop Prop-41), ...}
Prop-41
Relation: Color
Value: Grey
Modality: MostAre
FromUnit: TypicalElephant
!-- OR --
AnyElephant
UniversalExamples: {x, ...}
x
UniversalIsa: {AnyElephant}
QualifiedBy: Most
DefinitionalSlots: {UniversalIsa, NatureOfQualification}
Color: Grey
Most
?
--------------
AnyElephant
UniversalExamples: {x, ...}
AnyGreyThing
StdExamples: {x, ...}
x
UniversalIsa: {AnyElephant}
QualifiedBy: Most
DefinitionalSlots: {UniveralIsa, QualifiedBy}
StdIsa: {AnyGreyThing}
Isa: {AnyGreyThing, AnyElephant}
!14. Tower of Hanoi
??
Predicate Calculus Statements for Various RLL things
(15-Oct-80)
Typed logic
u, u-i, u0, u1, u2, ... Satisfy Unitp, i.e. represents Units
s, s-i, s0, s1, s2, ... Satisfy Slotp, i.e. represents Slots
(subtype of Units)
f, f-i, f0, f1, f2, ... represents Functions
l, l-i, l0, l1, l2, ... Satisfy LISTP, i.e. represents Lists
t, t-i, t0, t1, t2, ... represents Times
[ p's are used for pseudo-slots ]
LISP OVERHEAD:
[Note- this is essentially MEMB]
∀ v,l. v in l ≡ [ (l ≠ NIL) & ( v = CAR(l) ∨ v in CDR(l) )]
Slot Related Overhead:
∀ s. HighLevelDefn( s ) = GetValue( s,'HighLevelDefn )
∀ s. Format( s ) = GetValue( s,'Format )
∀ s. Defn( s ) = GetValue( s,'Defn )
∀ s. Domain( s ) = GetValue( s,'Domain )
∀ s. Range( s ) = GetValue( s,'Range )
∀ u,s. GetValue-1( u,s ) = GetValue( u,s )
∀ u,s. GetValue( u,s ) = OR( UA-GETVALUE( u,s ), APPLY( Defn( s ), u ) )
∀ p. Format( p ) = CAR( Range( p ))
∀ p,HLD. HighLevelDefn( p ) = HLD ⊃
Parse( HLD ) = LIST( Defn( p ), Range( p ), Domain( p ), ? ).
∀ u,p. GetValue-1( u,p ) = APPLY( Defn( p ),u ).
∀ u,p,v. InValue( u,p,v ) ≡
{ [ (Format( p ) ε {FSingleton} ) & v = GetValue-1( u,p ) ]
[ (Format( p ) ε {FSet, FList} ) & v in GetValue-1( u,p ) ] }
CONSISTENCY:
∀ u,s,v,v',t0,t1,t2.
[ UA-PUTVALUE( u,s,v )(t0) & [t0<t1<t2 ⊃ ¬UA-PUTVALUE( u,s,v' )(t1) ] ] ⊃
UA-GETVALUE( u,s )(t2) = v.
∀ u,s,v,v',t0,t1,t2.
[ PutValue( u,s,v )(t0) & [t0<t1<t2 ⊃ ¬PutValue( u,s,v' )(t1) ] ] ⊃
GetValue( u,s )(t2) = v.
∀ s1,s2. s2 = GetValue( s1,'Inverse ) ⊃
[∀ u,v. InValue( u1,s,v ) ⊃ [Unitp( v ) & InValue( v,s2,u )] ]
SLOT DEFINATION:
COMPOSITION:
∀ p1,HLD,u. HLD = HighLevelDefn( p1 ) & Composition = CAR( HLD ) ⊃
∃ p2. HighLevelDefn( p2 ) = CAR (CDR ( HLD ) ) &
[IF CDR( CDR( HLD ) ) = NIL
THEN GetValue-1( u,p1 ) = GetValue-1( u,p2 )
ELSE ∃ p3. HighLevelDefn( p3 ) = CONS('Composition, CDR( CDR (HLD) ) )] &
∀ v. InValue( u,p2,v ) ⊃
Unitp( v ) & GetValue-1( v,p3 ) = GetValue-1( u,p1 )
UNIONING:
∀ p1,HLD,u. HLD = HighLevelDefn( p1 ) & Composition = CAR( HLD ) ⊃
[∃ p2. HighLevelDefn( p2 ) = CAR (CDR ( HLD ) ) &
∀ v. InValue( u,p2,v ) ⊃ InValue( u,p1,v )] &
[IF CDR( CDR( HLD ) ) ≠ NIL
THEN ∃ p3. HighLevelDefn( p3 ) = CONS('Unioning, CDR( CDR (HLD) ) )] &
∀ v. InValue( u,p2,v ) ⊃ InValue( u,p1,v )
STARRING:
∀ p1,HLD,u. HLD = HighLevelDefn( p1 ) & Starring = CAR( HLD ) ⊃
InValue( u,p2,u ) &
∃ p2. HighLevelDefn( p2 ) = CAR (CDR ( HLD ) ) &
∀ v,v1. InValue( u,p2,v ) ⊃
Unitp( v ) & [InValue( v,p1,v1 ) ⊃ InValue( u,p1,v1 ) ]
!TO CSD.GENESERETH, CSD.SMITH 13:38 17-June
Proposition:
RLL will come with a large (and extendable) set of Simulation Structures.
The initial ("top level") SS (that is, the starting setting for the
organ,) defines each SS as a set of linguistic elements (which are the set of
LISP functions,) only some of which have a semantic interpretation. That subset
is different for each SS; as is the actual interpretation.
(Hence, RDG's RLL has defined GetValue and PutValue, whereas MRG's version makes
no effort to define these, and instead worries about True and Value.)
These functions are used to access the information in the KB;
each SS somehow states that all the other symbols of LISP are
available to the user, but does not provide these linguistic elements
with any (pre-defined) semantics.
When creating a new KB, the user may
(1) indicate which SS he wishes
(2) indicate this KB will have a new type of SS - and will proceed to
to define it (using mechanisms of the current SS.)
Questions:
1) Does this seem feasible? Is it basically what you had in mind? What would you
want to change?
2) Should each KB have exactly 1 Simulation Structure associated with it?
Is this a limitation - when might a user wish a single KB to have
more than one SS?
3) How many functions should there be for accessing the KB? I believe this
number should be small, and these functions should have a good "semantics".
Comments in general.
What's in a Language?
∂TO CSD.SMITH, CSD.GENESERETH, STT (?/80)
List of terms to be defined -- or at least have a common
meaning to those of us here:
Language
A set of words and a grammar. Note this is a-semantic.
They are inherently Linguistic entitites -- in the manner of
a grammar is. [See RWW's LS-pairs, ie Language/Structure]
Representation
A mapping between words in a language and objects,
relationships, etc. in the (some) world.
Representation is both an interpretation and a set of symbols
In this sense, language is a component of a representation
[See SIGART, p. 68-9 for defn, p.5 for illustration of difficulties]
Representation Language
Corresponds to "real world" IN NATURAL WAY -
so the pieces are easy to manipulate
Each is a scheme for constructing and augmenting
a representation, including tools for facilitating this process.
Note than a representation language IS A representation and a language.
Representational Components
Pieces used in a representation languages.
Representation Language Language
A scheme for constructing and augmenting
a representation language, including tools for facilitating same.
Note than a representation language language IS A representation language.
Linguistic
Epistemologic
(Epistemological neutrality)
Semantics
Syntax
Model
Interpretation
Frame/Schema/Unit
Slot
Proposition
Inheritance
Default
Modality
Object Centered
Function Centered
Stream Centered
"Reason maintanence" (nee "Truth maintanence")
Justification
Meta-level
Instance
Perspective/View
Self-descriptive
Self-modifiable
Specific to RLL
---------------
Slot Type
Class of Units
Typical Member
!∂07-Oct-80 0742 CSD.SMITH at SU-SCORE Re: Start of Glossary
Date: 7 Oct 1980 0736-PDT
From: CSD.SMITH at SU-SCORE
Subject: Re: Start of Glossary
To: RDG at SU-AI
In-Reply-To: Your message of 6-Oct-80 1659-PDT
RPLACA(("Truth maintenance" ...) "Reason maintenance"]
-------
Date: 27 Oct 1980 1217-PST
From: CSD.SMITH
Subject: next meeting
To: CSD.GENESERETH, CSD.SMITH, CSD.GREINER, CSD.STT, csd.bennett, JD at SU-AI,
LGC at SU-AI, CSD.CPP, RMS at SU-AI
For this fridays representation meeting the subject will be SDL and FOL.
Readings are Weyrauch's PROLEGOMENA (in recent AI Journal issue)
and Dolyle's SDL chapter (chapter 2).
Also you might think about the following questions (which I hope we can reach
a consensus on):
What is a "representation"?
What is a "theory"? Are they equivalent?
What does it mean to be an "object" or "individual"?
(If you think this question is easy, think about your desk or
office as being a quantum-mechanical wave function.)
What is the relationship between theories and contexts?
What would it mean for a theory to refer to itself?
What would it mean for a process to (have a theory of and) change itself
...etc.
Cheers. Dave.
-------
---------------
-------
Questions re: RLL
1-Aug-80 13:16:09-PDT,0000000708;000000000001
Date: 1 Aug 1980 1316-PDT
From: CSD.HINES
Subject: question on rll mechanism
To: csd.greiner
Russ,
Can or how does one refer to slots or units inside LISP code?
What I mean is in writing a resolving function, I would like to refer
to a few slots which may need to be searched for via Isa's links.
Example: A resolving function needs to know if the two clauses that
it has picked out have been previosly resolved together in the same
manner. To do this I plan to create the slot under ClauseSet called
Resolewe which will contained a list of (clause sigma) where clause is the
name of a clause which has been resolved with the queried clause and sigma
is the unification used.
-------
13-Nov-80 10:31:23-PST,00000002194;000000000001
Date: 13 Nov 1980 1029-PST
From: CSD.HINES
Subject: πGetValue/ToGetValue/Epistemological paradoxes
To: csd.greiner
In reading through Appendix A of RLL, I seem to have tied
myself in a knot. On page 27, line 5-15, does GetValue actually
cycle through l6-10 until it comes to (GetValue 'Togetvalue 'Togetvalue)
at which time it 'knows' to stop this recursion and actually look at
the value of ToGetValue:ToGetValue, GetAccessFn? This would seem to
be the wrong approach for 2 reasons:
1) It's artificial (Maybe this is O.K. since it is Artificial
Intelligence). I don't require knowledge about how my brain
retrieves information before I can actually retrieve it. The
The knowledge about retrieval (i.e what would be the value of
ToGetValue:ToGetValue) is not crucial to the process itself.
[It is only important when modification is needed which presumably
is done by an entirely different agent. I don't even want to
start thinking about a "self-modifiable" system.]
2) It's circular. At some point GetValue must stop asking the
question "How do I get this Value" and must actually go to
the slot: ToGetValue of the Unit: ToGetValue and find this
fn.: GetAccessFn which tells it (I think) how to get a value.
I.E. To answer the question "How do I get a value?" it goes to
the slot which says "Among other things, You go to slots to see
their value." To this RLL replies "I see, I do what I just did,
right?" In other words, going to te value of ToGetValue
presupposes knowledge that it suupposedly is garnering by going
there.
So, I will assume (until 3:00 today when I will hopefully see you) that
GetValue is "hardwired" in some way and that while knowledge exists about
how it works (if nowhere else in your head) this knowledge is not
necessary to its functioning. This seems to indicate that RLL could
only be modified by an external agent.
Does any of this make sense. If not, at least you'll be a little
better prepared to answer my questions this afternoon.
-------
-------